package com.atdel.demo22;


import com.atdel.demo06.User;

import java.lang.reflect.Field;

/**
 * @BelongsProject: java_study
 * @BelongsPackage: com.atdel.demo22
 * @Author: Del
 * @CreateTime: 2025-03-18  11:10
 * @Description: TODO
 * @Version: 1.0
 */
public class SqlGenerate {
    public static String generateSelect(Class<?> clz) {
        // 获取类的属性数组
        Field[] declaredFields = clz.getDeclaredFields();

        // 更改属性的权限
        for (Field field : declaredFields) {
            field.setAccessible(true);
        }
        // 拼接SQL语句
        StringBuilder sb = new StringBuilder();
        sb.append("SELECT ");

        // 遍历属性数组，将属性名拼接到SQL语句中
        for (int i = 0; i < declaredFields.length; i++) {
            // 获取属性
            Field field = declaredFields[i];
            // 将属性名拼接到SQL语句中
            sb.append(field.getName());
            if (i < declaredFields.length - 1) {
                // 如果不是最后一个属性，则添加逗号
                sb.append(",");
            }
        }
        // 添加表名
        sb.append(" FROM ");
        // 对表明进行处理 从第二个大写字母处理 添加 _
        sb.append(getTransitionTable(clz.getSimpleName()));
        return sb.toString();
    }


    /**
     * 根据类上的注解生成 SELECT SQL 语句。
     *
     * @param clz 输入的类
     * @return 生成的 SQL 语句
     * @throws IllegalArgumentException 如果类上没有 @Table 注解
     */
    public static String generateAnnotationSelect(Class<?> clz) {
        // 输入校验
        if (clz == null) {
            throw new IllegalArgumentException("输入的类不能为空");
        }
        // 获取表名
        String tableName = getTableName(clz);

        // 获取列名
        StringBuilder columns = new StringBuilder();
        try {
            // 遍历字段，获取 @Column 注解对应的列名
            for (Field field : clz.getDeclaredFields()) {
                // 获取字段上的 @Column 注解对应的列名
                String columnName = getColumnName(field);
                // 如果列名不为空，则添加到列名字符串中
                if (columnName != null && !columnName.isEmpty()) {
                    // 如果是第一个字段，则不添加逗号
                    if (columns.length() > 0) {
                        columns.append(",");
                    }
                    // 添加列名
                    columns.append(columnName);
                }
            }
        } catch (SecurityException e) {
            throw new RuntimeException("无法访问类的字段", e);
        }

        // 输入校验
        if (columns.length() == 0) {
            throw new IllegalArgumentException("类上缺少有效的 @Column 注解");
        }

        // 构建 SQL 语句
        return "SELECT " + columns.toString() + " FROM " + tableName;
    }

    /**
     * 获取类上的 @Table 注解对应的表名。
     *
     * @param clz 输入的类
     * @return 表名
     */
    private static String getTableName(Class<?> clz) {
        // 获取类上的 @Table 注解
        if (clz.isAnnotationPresent(Table.class)) {
            // 获取注解的 value 属性，即表名
            Table table = clz.getAnnotation(Table.class);
            // 返回表名
            return table.value();
        }
        // 如果没有 @Table 注解 正常获取类名进行转换
        return getTransitionTable(clz.getSimpleName());
    }

    /**
     * 获取字段上的 @Column 注解对应的列名。
     *
     * @param field 输入的字段
     * @return 列名
     */
    private static String getColumnName(Field field) {
        // 获取字段上的 @Column 注解
        if (field.isAnnotationPresent(Column.class)) {
            // 获取注解的 columnName 属性，即列名
            Column column = field.getAnnotation(Column.class);
            // 返回列名
            return column.columnName();
        }
        return null;
    }

    public static String getTransitionTable(String tableName) {
        // 使用正则表达式处理表名
        String regex = "^[a-z0-9]+(_[a-z0-9]+)*$"; // 支持数字和下划线分隔的小写字母
        // 输入校验
        if (tableName.isEmpty()) {
            throw new IllegalArgumentException("表名不能为空");
        }
        // 判断是否符合正则表达式
        if (!tableName.matches(regex)) {
            StringBuilder result = new StringBuilder();
            boolean previousIsUnderscore = false;
            for (int i = 0; i < tableName.length(); i++) {
                char c = tableName.charAt(i);
                if (Character.isUpperCase(c)) {
                    // 如果当前字符是大写字母且前一个字符不是下划线，则添加下划线
                    if (i > 0 && !previousIsUnderscore) {
                        result.append("_");
                    }
                    result.append(Character.toLowerCase(c));
                    previousIsUnderscore = false;
                } else if (c == '_') {
                    // 处理连续下划线的情况
                    if (!previousIsUnderscore) {
                        result.append(c);
                        previousIsUnderscore = true;
                    }
                } else {
                    // 其他字符直接追加
                    result.append(Character.toLowerCase(c));
                    previousIsUnderscore = false;
                }
            }
            tableName = result.toString();
        }
        return tableName;
    }

    public static void main(String[] args) {
//        String sql = generateSelect(UserInfo.class);
//        System.out.println(sql);

        String sql2 = generateAnnotationSelect(UserInfo.class);
        System.out.println(sql2);
    }
}
